diff --git a/keyserver/src/responders/website-responders.js b/keyserver/src/responders/website-responders.js
index d0b139206..cf0eb6bca 100644
--- a/keyserver/src/responders/website-responders.js
+++ b/keyserver/src/responders/website-responders.js
@@ -1,829 +1,829 @@
// @flow
import html from 'common-tags/lib/html/index.js';
import { detect as detectBrowser } from 'detect-browser';
import type { $Response, $Request } from 'express';
import fs from 'fs';
import _isEqual from 'lodash/fp/isEqual.js';
import _keyBy from 'lodash/fp/keyBy.js';
import * as React from 'react';
// eslint-disable-next-line import/extensions
import ReactDOMServer from 'react-dom/server';
import t from 'tcomb';
import { promisify } from 'util';
import { inviteLinkUrl } from 'lib/facts/links.js';
import { baseLegalPolicies } from 'lib/facts/policies.js';
import stores from 'lib/facts/stores.js';
import { daysToEntriesFromEntryInfos } from 'lib/reducers/entry-reducer.js';
import { freshMessageStore } from 'lib/reducers/message-reducer.js';
import { mostRecentlyReadThread } from 'lib/selectors/thread-selectors.js';
import { mostRecentMessageTimestamp } from 'lib/shared/message-utils.js';
import {
threadHasPermission,
threadIsPending,
parsePendingThreadID,
createPendingThread,
} from 'lib/shared/thread-utils.js';
import { defaultWebEnabledApps } from 'lib/types/enabled-apps.js';
import { entryStoreValidator } from 'lib/types/entry-types.js';
import { defaultCalendarFilters } from 'lib/types/filter-types.js';
import { keyserverStoreValidator } from 'lib/types/keyserver-types.js';
import { inviteLinksStoreValidator } from 'lib/types/link-types.js';
import {
defaultNumberPerThread,
messageStoreValidator,
} from 'lib/types/message-types.js';
import { defaultEnabledReports } from 'lib/types/report-types.js';
import { defaultConnectionInfo } from 'lib/types/socket-types.js';
import { threadPermissions } from 'lib/types/thread-permission-types.js';
import { threadTypes } from 'lib/types/thread-types-enum.js';
import { threadStoreValidator } from 'lib/types/thread-types.js';
import {
currentUserInfoValidator,
userInfosValidator,
} from 'lib/types/user-types.js';
import { currentDateInTimeZone } from 'lib/utils/date-utils.js';
import { ServerError } from 'lib/utils/errors.js';
import { promiseAll } from 'lib/utils/promises.js';
import { defaultNotifPermissionAlertInfo } from 'lib/utils/push-alerts.js';
import { infoFromURL, urlInfoValidator } from 'lib/utils/url-utils.js';
import {
tBool,
tNumber,
tShape,
tString,
ashoatKeyserverID,
} from 'lib/utils/validation-utils.js';
import getTitle from 'web/title/getTitle.js';
import { navInfoValidator } from 'web/types/nav-types.js';
import { navInfoFromURL } from 'web/url-utils.js';
import { fetchEntryInfos } from '../fetchers/entry-fetchers.js';
import { fetchPrimaryInviteLinks } from '../fetchers/link-fetchers.js';
import { fetchMessageInfos } from '../fetchers/message-fetchers.js';
import { hasAnyNotAcknowledgedPolicies } from '../fetchers/policy-acknowledgment-fetchers.js';
import { fetchThreadInfos } from '../fetchers/thread-fetchers.js';
import {
fetchCurrentUserInfo,
fetchKnownUserInfos,
fetchUserInfos,
} from '../fetchers/user-fetchers.js';
import { getWebPushConfig } from '../push/providers.js';
import { setNewSession } from '../session/cookies.js';
import { Viewer } from '../session/viewer.js';
import { streamJSON, waitForStream } from '../utils/json-stream.js';
import {
getAppURLFactsFromRequestURL,
getCommAppURLFacts,
} from '../utils/urls.js';
import { validateOutput, validateInput } from '../utils/validation-utils.js';
const { renderToNodeStream } = ReactDOMServer;
const access = promisify(fs.access);
const readFile = promisify(fs.readFile);
const googleFontsURL =
'https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600&display=swap';
const localFontsURL = 'fonts/local-fonts.css';
async function getFontsURL() {
try {
await access(localFontsURL);
return localFontsURL;
} catch {
return googleFontsURL;
}
}
type AssetInfo = {
+jsURL: string,
+fontsURL: string,
+cssInclude: string,
+olmFilename: string,
+commQueryExecutorFilename: string,
+opaqueURL: string,
};
let assetInfo: ?AssetInfo = null;
async function getAssetInfo() {
if (assetInfo) {
return assetInfo;
}
if (process.env.NODE_ENV === 'development') {
const fontsURL = await getFontsURL();
assetInfo = {
jsURL: 'http://localhost:8080/dev.build.js',
fontsURL,
cssInclude: '',
olmFilename: '',
commQueryExecutorFilename: '',
opaqueURL: 'http://localhost:8080/opaque-ke.wasm',
};
return assetInfo;
}
try {
const manifestString = await readFile('../web/dist/manifest.json', 'utf8');
const manifest = JSON.parse(manifestString);
const webworkersManifestString = await readFile(
'../web/dist/webworkers/manifest.json',
'utf8',
);
const webworkersManifest = JSON.parse(webworkersManifestString);
assetInfo = {
jsURL: `compiled/${manifest['browser.js']}`,
fontsURL: googleFontsURL,
cssInclude: html`
`,
olmFilename: manifest['olm.wasm'],
commQueryExecutorFilename: webworkersManifest['comm_query_executor.wasm'],
opaqueURL: `compiled/${manifest['comm_opaque2_wasm_bg.wasm']}`,
};
return assetInfo;
} catch {
throw new Error(
'Could not load manifest.json for web build. ' +
'Did you forget to run `yarn dev` in the web folder?',
);
}
}
let webpackCompiledRootComponent: ?React.ComponentType<{}> = null;
async function getWebpackCompiledRootComponentForSSR() {
if (webpackCompiledRootComponent) {
return webpackCompiledRootComponent;
}
try {
// $FlowFixMe web/dist doesn't always exist
const webpackBuild = await import('web/dist/app.build.cjs');
webpackCompiledRootComponent = webpackBuild.app.default;
return webpackCompiledRootComponent;
} catch {
throw new Error(
'Could not load app.build.cjs. ' +
'Did you forget to run `yarn dev` in the web folder?',
);
}
}
const initialReduxStateValidator = tShape({
navInfo: navInfoValidator,
deviceID: t.Nil,
currentUserInfo: currentUserInfoValidator,
draftStore: t.irreducible('default draftStore', _isEqual({ drafts: {} })),
entryStore: entryStoreValidator,
threadStore: threadStoreValidator,
userStore: tShape({
userInfos: userInfosValidator,
inconsistencyReports: t.irreducible(
'default inconsistencyReports',
_isEqual([]),
),
}),
messageStore: messageStoreValidator,
loadingStatuses: t.irreducible('default loadingStatuses', _isEqual({})),
calendarFilters: t.irreducible(
'defaultCalendarFilters',
_isEqual(defaultCalendarFilters),
),
communityPickerStore: t.irreducible(
'default communityPickerStore',
_isEqual({ chat: null, calendar: null }),
),
windowDimensions: t.irreducible(
'default windowDimensions',
_isEqual({ width: 0, height: 0 }),
),
notifPermissionAlertInfo: t.irreducible(
'default notifPermissionAlertInfo',
_isEqual(defaultNotifPermissionAlertInfo),
),
actualizedCalendarQuery: tShape({
startDate: t.String,
endDate: t.String,
filters: t.irreducible('default filters', _isEqual(defaultCalendarFilters)),
}),
watchedThreadIDs: t.irreducible('default watchedThreadIDs', _isEqual([])),
lifecycleState: tString('active'),
enabledApps: t.irreducible(
'defaultWebEnabledApps',
_isEqual(defaultWebEnabledApps),
),
reportStore: t.irreducible(
'default reportStore',
_isEqual({
enabledReports: defaultEnabledReports,
queuedReports: [],
}),
),
nextLocalID: tNumber(0),
deviceToken: t.Nil,
dataLoaded: t.Boolean,
windowActive: tBool(true),
userPolicies: t.irreducible('default userPolicies', _isEqual({})),
cryptoStore: t.irreducible(
'default cryptoStore',
_isEqual({
primaryIdentityKeys: null,
notificationIdentityKeys: null,
}),
),
pushApiPublicKey: t.maybe(t.String),
_persist: t.Nil,
commServicesAccessToken: t.Nil,
inviteLinksStore: inviteLinksStoreValidator,
lastCommunicatedPlatformDetails: t.irreducible(
'default lastCommunicatedPlatformDetails',
- _isEqual({}),
+ _isEqual(null),
),
keyserverStore: keyserverStoreValidator,
});
async function websiteResponder(
viewer: Viewer,
req: $Request,
res: $Response,
): Promise {
const appURLFacts = getAppURLFactsFromRequestURL(req.originalUrl);
const { basePath, baseDomain } = appURLFacts;
const baseURL = basePath.replace(/\/$/, '');
const urlPrefix = baseDomain + baseURL;
const loadingPromise = getWebpackCompiledRootComponentForSSR();
const hasNotAcknowledgedPoliciesPromise = hasAnyNotAcknowledgedPolicies(
viewer.id,
baseLegalPolicies,
);
const initialNavInfoPromise = (async () => {
try {
let urlInfo = infoFromURL(decodeURI(req.url));
try {
urlInfo = await validateInput(viewer, urlInfoValidator, urlInfo, true);
} catch (exc) {
// We should still be able to handle older links
if (exc.message !== 'invalid_client_id_prefix') {
throw exc;
}
}
let backupInfo = {
now: currentDateInTimeZone(viewer.timeZone),
};
// Some user ids in selectedUserList might not exist in the userStore
// (e.g. they were included in the results of the user search endpoint)
// Because of that we keep their userInfos inside the navInfo.
if (urlInfo.selectedUserList) {
const fetchedUserInfos = await fetchUserInfos(urlInfo.selectedUserList);
const userInfos = {};
for (const userID in fetchedUserInfos) {
const userInfo = fetchedUserInfos[userID];
if (userInfo.username) {
userInfos[userID] = userInfo;
}
}
backupInfo = { userInfos, ...backupInfo };
}
return navInfoFromURL(urlInfo, backupInfo);
} catch (e) {
throw new ServerError(e.message);
}
})();
const calendarQueryPromise = (async () => {
const initialNavInfo = await initialNavInfoPromise;
return {
startDate: initialNavInfo.startDate,
endDate: initialNavInfo.endDate,
filters: defaultCalendarFilters,
};
})();
const messageSelectionCriteria = { joinedThreads: true };
const initialTime = Date.now();
const assetInfoPromise = getAssetInfo();
const threadInfoPromise = fetchThreadInfos(viewer);
const messageInfoPromise = fetchMessageInfos(
viewer,
messageSelectionCriteria,
defaultNumberPerThread,
);
const entryInfoPromise = (async () => {
const calendarQuery = await calendarQueryPromise;
return await fetchEntryInfos(viewer, [calendarQuery]);
})();
const currentUserInfoPromise = fetchCurrentUserInfo(viewer);
const userInfoPromise = fetchKnownUserInfos(viewer);
const sessionIDPromise = (async () => {
const calendarQuery = await calendarQueryPromise;
if (viewer.loggedIn) {
await setNewSession(viewer, calendarQuery, initialTime);
}
return viewer.sessionID;
})();
const threadStorePromise = (async () => {
const [{ threadInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
threadInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
return { threadInfos: hasNotAcknowledgedPolicies ? {} : threadInfos };
})();
const messageStorePromise = (async () => {
const [
{ threadInfos },
{ rawMessageInfos, truncationStatuses },
hasNotAcknowledgedPolicies,
] = await Promise.all([
threadInfoPromise,
messageInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
if (hasNotAcknowledgedPolicies) {
return {
messages: {},
threads: {},
local: {},
currentAsOf: { [ashoatKeyserverID]: 0 },
};
}
const { messageStore: freshStore } = freshMessageStore(
rawMessageInfos,
truncationStatuses,
mostRecentMessageTimestamp(rawMessageInfos, initialTime),
threadInfos,
);
return freshStore;
})();
const entryStorePromise = (async () => {
const [{ rawEntryInfos }, hasNotAcknowledgedPolicies] = await Promise.all([
entryInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
if (hasNotAcknowledgedPolicies) {
return {
entryInfos: {},
daysToEntries: {},
lastUserInteractionCalendar: 0,
};
}
return {
entryInfos: _keyBy('id')(rawEntryInfos),
daysToEntries: daysToEntriesFromEntryInfos(rawEntryInfos),
lastUserInteractionCalendar: initialTime,
};
})();
const userStorePromise = (async () => {
const [userInfos, hasNotAcknowledgedPolicies] = await Promise.all([
userInfoPromise,
hasNotAcknowledgedPoliciesPromise,
]);
return {
userInfos: hasNotAcknowledgedPolicies ? {} : userInfos,
inconsistencyReports: [],
};
})();
const navInfoPromise = (async () => {
const [
{ threadInfos },
messageStore,
currentUserInfo,
userStore,
finalNavInfo,
] = await Promise.all([
threadInfoPromise,
messageStorePromise,
currentUserInfoPromise,
userStorePromise,
initialNavInfoPromise,
]);
const requestedActiveChatThreadID = finalNavInfo.activeChatThreadID;
if (
requestedActiveChatThreadID &&
!threadIsPending(requestedActiveChatThreadID) &&
!threadHasPermission(
threadInfos[requestedActiveChatThreadID],
threadPermissions.VISIBLE,
)
) {
finalNavInfo.activeChatThreadID = null;
}
if (!finalNavInfo.activeChatThreadID) {
const mostRecentThread = mostRecentlyReadThread(
messageStore,
threadInfos,
);
if (mostRecentThread) {
finalNavInfo.activeChatThreadID = mostRecentThread;
}
}
if (
finalNavInfo.activeChatThreadID &&
threadIsPending(finalNavInfo.activeChatThreadID) &&
finalNavInfo.pendingThread?.id !== finalNavInfo.activeChatThreadID
) {
const pendingThreadData = parsePendingThreadID(
finalNavInfo.activeChatThreadID,
);
if (
pendingThreadData &&
pendingThreadData.threadType !== threadTypes.SIDEBAR &&
currentUserInfo.id
) {
const { userInfos } = userStore;
const members = [...pendingThreadData.memberIDs, currentUserInfo.id]
.map(id => {
const userInfo = userInfos[id];
if (!userInfo || !userInfo.username) {
return undefined;
}
const { username } = userInfo;
return { id, username };
})
.filter(Boolean);
const newPendingThread = createPendingThread({
viewerID: currentUserInfo.id,
threadType: pendingThreadData.threadType,
members,
});
finalNavInfo.activeChatThreadID = newPendingThread.id;
finalNavInfo.pendingThread = newPendingThread;
}
}
return finalNavInfo;
})();
const currentAsOfPromise = (async () => {
const hasNotAcknowledgedPolicies = await hasNotAcknowledgedPoliciesPromise;
return hasNotAcknowledgedPolicies ? 0 : initialTime;
})();
const pushApiPublicKeyPromise = (async () => {
const pushConfig = await getWebPushConfig();
if (!pushConfig) {
if (process.env.NODE_ENV !== 'development') {
console.warn('keyserver/secrets/web_push_config.json should exist');
}
return null;
}
return pushConfig.publicKey;
})();
const inviteLinksStorePromise = (async () => {
const primaryInviteLinks = await fetchPrimaryInviteLinks(viewer);
const links = {};
for (const link of primaryInviteLinks) {
if (link.primary) {
links[link.communityID] = {
primaryLink: link,
};
}
}
return {
links,
};
})();
const keyserverStorePromise = (async () => {
const { sessionID, updatesCurrentAsOf } = await promiseAll({
sessionID: sessionIDPromise,
updatesCurrentAsOf: currentAsOfPromise,
});
return {
keyserverInfos: {
[ashoatKeyserverID]: {
cookie: undefined,
sessionID,
updatesCurrentAsOf,
urlPrefix,
connection: defaultConnectionInfo,
},
},
};
})();
const {
jsURL,
fontsURL,
cssInclude,
olmFilename,
opaqueURL,
commQueryExecutorFilename,
} = await assetInfoPromise;
// prettier-ignore
res.write(html`
${getTitle(0)}
${cssInclude}
`);
const Loading = await loadingPromise;
const reactStream = renderToNodeStream();
reactStream.pipe(res, { end: false });
await waitForStream(reactStream);
res.write(html`
`);
}
const inviteSecretRegex = /^[a-z0-9]+$/i;
// On native, if this responder is called, it means that the app isn't
// installed.
async function inviteResponder(req: $Request, res: $Response): Promise {
const { secret } = req.params;
const userAgent = req.get('User-Agent');
const detectionResult = detectBrowser(userAgent);
if (detectionResult.os === 'Android OS') {
const isSecretValid = inviteSecretRegex.test(secret);
const referrer = isSecretValid
? `&referrer=${encodeURIComponent(`utm_source=invite/${secret}`)}`
: '';
const redirectUrl = `${stores.googlePlayUrl}${referrer}`;
res.writeHead(301, {
Location: redirectUrl,
});
res.end();
return;
} else if (detectionResult.os !== 'iOS') {
const urlFacts = getCommAppURLFacts();
const baseDomain = urlFacts?.baseDomain ?? '';
const basePath = urlFacts?.basePath ?? '/';
const redirectUrl = `${baseDomain}${basePath}handle/invite/${secret}`;
res.writeHead(301, {
Location: redirectUrl,
});
res.end();
return;
}
const fontsURL = await getFontsURL();
res.end(html`
Comm
To join this community, download the Comm app and reopen this invite
link
Visit Comm’s website
`);
}
export { websiteResponder, inviteResponder };
diff --git a/lib/reducers/last-communicated-platform-details-reducer.js b/lib/reducers/last-communicated-platform-details-reducer.js
index d8fc3d9a3..306b53def 100644
--- a/lib/reducers/last-communicated-platform-details-reducer.js
+++ b/lib/reducers/last-communicated-platform-details-reducer.js
@@ -1,35 +1,28 @@
// @flow
import { updateLastCommunicatedPlatformDetailsActionType } from '../actions/device-actions.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {
logInActionTypes,
registerActionTypes,
} from '../actions/user-actions.js';
-import type { LastCommunicatedPlatformDetails } from '../types/device-types';
+import type { PlatformDetails } from '../types/device-types';
import type { BaseAction } from '../types/redux-types';
import { getConfig } from '../utils/config.js';
export default function reduceLastCommunicatedPlatformDetails(
- state: LastCommunicatedPlatformDetails,
+ state: ?PlatformDetails,
action: BaseAction,
- currentURLPrefix: string,
-): LastCommunicatedPlatformDetails {
+): ?PlatformDetails {
if (
action.type === logInActionTypes.success ||
action.type === siweAuthActionTypes.success ||
action.type === registerActionTypes.success
) {
- return {
- ...state,
- [currentURLPrefix]: getConfig().platformDetails,
- };
+ return getConfig().platformDetails;
}
if (action.type === updateLastCommunicatedPlatformDetailsActionType) {
- return {
- ...state,
- ...action.payload,
- };
+ return action.payload;
}
return state;
}
diff --git a/lib/reducers/master-reducer.js b/lib/reducers/master-reducer.js
index 64788dcb1..57e06ab16 100644
--- a/lib/reducers/master-reducer.js
+++ b/lib/reducers/master-reducer.js
@@ -1,162 +1,161 @@
// @flow
import reduceCalendarFilters from './calendar-filters-reducer.js';
import { reduceCalendarQuery } from './calendar-query-reducer.js';
import reduceDataLoaded from './data-loaded-reducer.js';
import { reduceDeviceToken } from './device-token-reducer.js';
import { reduceDraftStore } from './draft-reducer.js';
import reduceEnabledApps from './enabled-apps-reducer.js';
import { reduceEntryInfos } from './entry-reducer.js';
import reduceInviteLinks from './invite-links-reducer.js';
import reduceKeyserverStore from './keyserver-reducer.js';
import reduceLastCommunicatedPlatformDetails from './last-communicated-platform-details-reducer.js';
import reduceLifecycleState from './lifecycle-state-reducer.js';
import { reduceLoadingStatuses } from './loading-reducer.js';
import reduceNextLocalID from './local-id-reducer.js';
import { reduceMessageStore } from './message-reducer.js';
import reduceBaseNavInfo from './nav-reducer.js';
import { reduceNotifPermissionAlertInfo } from './notif-permission-alert-info-reducer.js';
import policiesReducer from './policies-reducer.js';
import reduceReportStore from './report-store-reducer.js';
import reduceServicesAccessToken from './services-access-token-reducer.js';
import { reduceThreadInfos } from './thread-reducer.js';
import { reduceCurrentUserInfo, reduceUserInfos } from './user-reducer.js';
import { siweAuthActionTypes } from '../actions/siwe-actions.js';
import {
registerActionTypes,
logInActionTypes,
} from '../actions/user-actions.js';
import type { BaseNavInfo } from '../types/nav-types.js';
import type { BaseAppState, BaseAction } from '../types/redux-types.js';
import {
fullStateSyncActionType,
incrementalStateSyncActionType,
} from '../types/socket-types.js';
import type { StoreOperations } from '../types/store-ops-types.js';
import { ashoatKeyserverID } from '../utils/validation-utils.js';
export default function baseReducer>(
state: T,
action: BaseAction,
): { state: T, storeOperations: StoreOperations } {
const { threadStore, newThreadInconsistencies, threadStoreOperations } =
reduceThreadInfos(state.threadStore, action);
const { threadInfos } = threadStore;
const [entryStore, newEntryInconsistencies] = reduceEntryInfos(
state.entryStore,
action,
threadInfos,
);
const newInconsistencies = [
...newEntryInconsistencies,
...newThreadInconsistencies,
];
// Only allow checkpoints to increase if we are connected
// or if the action is a STATE_SYNC
const { messageStoreOperations, messageStore: reducedMessageStore } =
reduceMessageStore(state.messageStore, action, threadInfos);
let messageStore = reducedMessageStore;
let keyserverStore = reduceKeyserverStore(state.keyserverStore, action);
if (
keyserverStore.keyserverInfos[ashoatKeyserverID].connection.status !==
'connected' &&
action.type !== incrementalStateSyncActionType &&
action.type !== fullStateSyncActionType &&
action.type !== registerActionTypes.success &&
action.type !== logInActionTypes.success &&
action.type !== siweAuthActionTypes.success
) {
if (
messageStore.currentAsOf[ashoatKeyserverID] !==
state.messageStore.currentAsOf[ashoatKeyserverID]
) {
messageStore = {
...messageStore,
currentAsOf: {
...messageStore.currentAsOf,
[ashoatKeyserverID]:
state.messageStore.currentAsOf[ashoatKeyserverID],
},
};
}
if (
keyserverStore.keyserverInfos[ashoatKeyserverID].updatesCurrentAsOf !==
state.keyserverStore.keyserverInfos[ashoatKeyserverID].updatesCurrentAsOf
) {
const keyserverInfos = { ...keyserverStore.keyserverInfos };
keyserverInfos[ashoatKeyserverID] = {
...keyserverInfos[ashoatKeyserverID],
updatesCurrentAsOf:
state.keyserverStore.keyserverInfos[ashoatKeyserverID]
.updatesCurrentAsOf,
};
keyserverStore = { ...keyserverStore, keyserverInfos };
}
}
const { draftStore, draftStoreOperations } = reduceDraftStore(
state.draftStore,
action,
);
const { reportStore, reportStoreOperations } = reduceReportStore(
state.reportStore,
action,
newInconsistencies,
);
return {
state: {
...state,
navInfo: reduceBaseNavInfo(state.navInfo, action),
draftStore,
entryStore,
loadingStatuses: reduceLoadingStatuses(state.loadingStatuses, action),
currentUserInfo: reduceCurrentUserInfo(state.currentUserInfo, action),
threadStore,
userStore: reduceUserInfos(state.userStore, action),
messageStore,
calendarFilters: reduceCalendarFilters(
state.calendarFilters,
action,
threadStore,
),
notifPermissionAlertInfo: reduceNotifPermissionAlertInfo(
state.notifPermissionAlertInfo,
action,
),
actualizedCalendarQuery: reduceCalendarQuery(
state.actualizedCalendarQuery,
action,
),
lifecycleState: reduceLifecycleState(state.lifecycleState, action),
enabledApps: reduceEnabledApps(state.enabledApps, action),
reportStore,
nextLocalID: reduceNextLocalID(state.nextLocalID, action),
dataLoaded: reduceDataLoaded(state.dataLoaded, action),
userPolicies: policiesReducer(state.userPolicies, action),
deviceToken: reduceDeviceToken(state.deviceToken, action),
commServicesAccessToken: reduceServicesAccessToken(
state.commServicesAccessToken,
action,
),
inviteLinksStore: reduceInviteLinks(state.inviteLinksStore, action),
lastCommunicatedPlatformDetails: reduceLastCommunicatedPlatformDetails(
state.lastCommunicatedPlatformDetails,
action,
- state.keyserverStore.keyserverInfos[ashoatKeyserverID].urlPrefix,
),
keyserverStore,
},
storeOperations: {
draftStoreOperations,
threadStoreOperations,
messageStoreOperations,
reportStoreOperations,
},
};
}
diff --git a/lib/selectors/server-calls.js b/lib/selectors/server-calls.js
index 2ed89e8db..16a18452b 100644
--- a/lib/selectors/server-calls.js
+++ b/lib/selectors/server-calls.js
@@ -1,53 +1,53 @@
// @flow
import { createSelector } from 'reselect';
import {
cookieSelector,
sessionIDSelector,
urlPrefixSelector,
connectionSelector,
} from './keyserver-selectors.js';
-import type { LastCommunicatedPlatformDetails } from '../types/device-types.js';
+import type { PlatformDetails } from '../types/device-types.js';
import type { AppState } from '../types/redux-types.js';
import type {
ConnectionInfo,
ConnectionStatus,
} from '../types/socket-types.js';
import { type CurrentUserInfo } from '../types/user-types.js';
export type ServerCallState = {
+cookie: ?string,
+urlPrefix: ?string,
+sessionID: ?string,
+currentUserInfo: ?CurrentUserInfo,
+connectionStatus: ?ConnectionStatus,
- +lastCommunicatedPlatformDetails: LastCommunicatedPlatformDetails,
+ +lastCommunicatedPlatformDetails: ?PlatformDetails,
};
const serverCallStateSelector: (state: AppState) => ServerCallState =
createSelector(
cookieSelector,
urlPrefixSelector,
sessionIDSelector,
(state: AppState) => state.currentUserInfo,
connectionSelector,
(state: AppState) => state.lastCommunicatedPlatformDetails,
(
cookie: ?string,
urlPrefix: ?string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionInfo: ?ConnectionInfo,
- lastCommunicatedPlatformDetails: LastCommunicatedPlatformDetails,
+ lastCommunicatedPlatformDetails: ?PlatformDetails,
) => ({
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus: connectionInfo?.status,
lastCommunicatedPlatformDetails,
}),
);
export { serverCallStateSelector };
diff --git a/lib/socket/socket.react.js b/lib/socket/socket.react.js
index d5ba148d6..bd0c9b557 100644
--- a/lib/socket/socket.react.js
+++ b/lib/socket/socket.react.js
@@ -1,787 +1,787 @@
// @flow
import invariant from 'invariant';
import _isEqual from 'lodash/fp/isEqual.js';
import _throttle from 'lodash/throttle.js';
import * as React from 'react';
import ActivityHandler from './activity-handler.react.js';
import APIRequestHandler from './api-request-handler.react.js';
import CalendarQueryHandler from './calendar-query-handler.react.js';
import { InflightRequests } from './inflight-requests.js';
import MessageHandler from './message-handler.react.js';
import ReportHandler from './report-handler.react.js';
import RequestResponseHandler from './request-response-handler.react.js';
import UpdateHandler from './update-handler.react.js';
import { updateActivityActionTypes } from '../actions/activity-actions.js';
import { updateLastCommunicatedPlatformDetailsActionType } from '../actions/device-actions.js';
import { logOutActionTypes } from '../actions/user-actions.js';
import { unsupervisedBackgroundActionType } from '../reducers/lifecycle-state-reducer.js';
import {
pingFrequency,
serverRequestSocketTimeout,
clientRequestVisualTimeout,
clientRequestSocketTimeout,
} from '../shared/timeouts.js';
import {
logInActionSources,
type LogOutResult,
} from '../types/account-types.js';
import { isWebPlatform, type PlatformDetails } from '../types/device-types.js';
import type { CalendarQuery } from '../types/entry-types.js';
import { forcePolicyAcknowledgmentActionType } from '../types/policy-types.js';
import type { Dispatch } from '../types/redux-types.js';
import {
serverRequestTypes,
type ClientClientResponse,
type ClientServerRequest,
} from '../types/request-types.js';
import {
type SessionState,
type SessionIdentification,
type PreRequestUserState,
} from '../types/session-types.js';
import {
clientSocketMessageTypes,
type ClientClientSocketMessage,
serverSocketMessageTypes,
type ClientServerSocketMessage,
stateSyncPayloadTypes,
fullStateSyncActionType,
incrementalStateSyncActionType,
updateConnectionStatusActionType,
type ConnectionInfo,
type ClientInitialClientSocketMessage,
type ClientResponsesClientSocketMessage,
type PingClientSocketMessage,
type AckUpdatesClientSocketMessage,
type APIRequestClientSocketMessage,
type ClientSocketMessageWithoutID,
type SocketListener,
type ConnectionStatus,
setLateResponseActionType,
type CommTransportLayer,
} from '../types/socket-types.js';
import { actionLogger } from '../utils/action-logger.js';
import type { DispatchActionPromise } from '../utils/action-utils.js';
import {
setNewSessionActionType,
fetchNewCookieFromNativeCredentials,
} from '../utils/action-utils.js';
import { getConfig } from '../utils/config.js';
import { ServerError, SocketTimeout, SocketOffline } from '../utils/errors.js';
import { promiseAll } from '../utils/promises.js';
import sleep from '../utils/sleep.js';
const remainingTimeAfterVisualTimeout =
clientRequestSocketTimeout - clientRequestVisualTimeout;
export type BaseSocketProps = {
+detectUnsupervisedBackgroundRef?: (
detectUnsupervisedBackground: (alreadyClosed: boolean) => boolean,
) => void,
};
type Props = {
...BaseSocketProps,
// Redux state
+active: boolean,
+openSocket: () => CommTransportLayer,
+getClientResponses: (
activeServerRequests: $ReadOnlyArray,
) => Promise<$ReadOnlyArray>,
+activeThread: ?string,
+sessionStateFunc: () => SessionState,
+sessionIdentification: SessionIdentification,
+cookie: ?string,
+urlPrefix: string,
+connection: ConnectionInfo,
+currentCalendarQuery: () => CalendarQuery,
+canSendReports: boolean,
+frozen: boolean,
+preRequestUserState: PreRequestUserState,
+noDataAfterPolicyAcknowledgment?: boolean,
+lastCommunicatedPlatformDetails: ?PlatformDetails,
// Redux dispatch functions
+dispatch: Dispatch,
+dispatchActionPromise: DispatchActionPromise,
// async functions that hit server APIs
+logOut: (preRequestUserState: PreRequestUserState) => Promise,
+socketCrashLoopRecovery?: () => Promise,
// keyserver olm sessions specific props
+getInitialNotificationsEncryptedMessage?: () => Promise,
};
type State = {
+inflightRequests: ?InflightRequests,
};
class Socket extends React.PureComponent {
state: State = {
inflightRequests: null,
};
socket: ?CommTransportLayer;
nextClientMessageID: number = 0;
listeners: Set = new Set();
pingTimeoutID: ?TimeoutID;
messageLastReceived: ?number;
reopenConnectionAfterClosing: boolean = false;
invalidationRecoveryInProgress: boolean = false;
initializedWithUserState: ?PreRequestUserState;
failuresAfterPolicyAcknowledgment: number = 0;
openSocket(newStatus: ConnectionStatus) {
if (
this.props.frozen ||
(!isWebPlatform(getConfig().platformDetails.platform) &&
(!this.props.cookie || !this.props.cookie.startsWith('user=')))
) {
return;
}
if (this.socket) {
const { status } = this.props.connection;
if (status === 'forcedDisconnecting') {
this.reopenConnectionAfterClosing = true;
return;
} else if (status === 'disconnecting' && this.socket.readyState === 1) {
this.markSocketInitialized();
return;
} else if (
status === 'connected' ||
status === 'connecting' ||
status === 'reconnecting'
) {
return;
}
if (this.socket.readyState < 2) {
this.socket.close();
console.log(`this.socket seems open, but Redux thinks it's ${status}`);
}
}
this.props.dispatch({
type: updateConnectionStatusActionType,
payload: { status: newStatus },
});
const socket = this.props.openSocket();
const openObject = {};
socket.onopen = () => {
if (this.socket === socket) {
this.initializeSocket();
openObject.initializeMessageSent = true;
}
};
socket.onmessage = this.receiveMessage;
socket.onclose = () => {
if (this.socket === socket) {
this.onClose();
}
};
this.socket = socket;
(async () => {
await sleep(clientRequestVisualTimeout);
if (this.socket !== socket || openObject.initializeMessageSent) {
return;
}
this.setLateResponse(-1, true);
await sleep(remainingTimeAfterVisualTimeout);
if (this.socket !== socket || openObject.initializeMessageSent) {
return;
}
this.finishClosingSocket();
})();
this.setState({
inflightRequests: new InflightRequests({
timeout: () => {
if (this.socket === socket) {
this.finishClosingSocket();
}
},
setLateResponse: (messageID: number, isLate: boolean) => {
if (this.socket === socket) {
this.setLateResponse(messageID, isLate);
}
},
}),
});
}
markSocketInitialized() {
this.props.dispatch({
type: updateConnectionStatusActionType,
payload: { status: 'connected' },
});
this.resetPing();
}
closeSocket(
// This param is a hack. When closing a socket there is a race between this
// function and the one to propagate the activity update. We make sure that
// the activity update wins the race by passing in this param.
activityUpdatePending: boolean,
) {
const { status } = this.props.connection;
if (status === 'disconnected') {
return;
} else if (status === 'disconnecting' || status === 'forcedDisconnecting') {
this.reopenConnectionAfterClosing = false;
return;
}
this.stopPing();
this.props.dispatch({
type: updateConnectionStatusActionType,
payload: { status: 'disconnecting' },
});
if (!activityUpdatePending) {
this.finishClosingSocket();
}
}
forceCloseSocket() {
this.stopPing();
const { status } = this.props.connection;
if (status !== 'forcedDisconnecting' && status !== 'disconnected') {
this.props.dispatch({
type: updateConnectionStatusActionType,
payload: { status: 'forcedDisconnecting' },
});
}
this.finishClosingSocket();
}
finishClosingSocket(receivedResponseTo?: ?number) {
const { inflightRequests } = this.state;
if (
inflightRequests &&
!inflightRequests.allRequestsResolvedExcept(receivedResponseTo)
) {
return;
}
if (this.socket && this.socket.readyState < 2) {
// If it's not closing already, close it
this.socket.close();
}
this.socket = null;
this.stopPing();
this.setState({ inflightRequests: null });
if (this.props.connection.status !== 'disconnected') {
this.props.dispatch({
type: updateConnectionStatusActionType,
payload: { status: 'disconnected' },
});
}
if (this.reopenConnectionAfterClosing) {
this.reopenConnectionAfterClosing = false;
if (this.props.active) {
this.openSocket('connecting');
}
}
}
reconnect: $Call void, number> = _throttle(
() => this.openSocket('reconnecting'),
2000,
);
componentDidMount() {
if (this.props.detectUnsupervisedBackgroundRef) {
this.props.detectUnsupervisedBackgroundRef(
this.detectUnsupervisedBackground,
);
}
if (this.props.active) {
this.openSocket('connecting');
}
}
componentWillUnmount() {
this.closeSocket(false);
this.reconnect.cancel();
}
componentDidUpdate(prevProps: Props) {
if (this.props.active && !prevProps.active) {
this.openSocket('connecting');
} else if (!this.props.active && prevProps.active) {
this.closeSocket(!!prevProps.activeThread);
} else if (
this.props.active &&
prevProps.openSocket !== this.props.openSocket
) {
// This case happens when the baseURL/urlPrefix is changed
this.reopenConnectionAfterClosing = true;
this.forceCloseSocket();
} else if (
this.props.active &&
this.props.connection.status === 'disconnected' &&
prevProps.connection.status !== 'disconnected' &&
!this.invalidationRecoveryInProgress
) {
this.reconnect();
}
}
render(): React.Node {
// It's important that APIRequestHandler get rendered first here. This is so
// that it is registered with Redux first, so that its componentDidUpdate
// processes before the other Handlers. This allows APIRequestHandler to
// register itself with action-utils before other Handlers call
// dispatchActionPromise in response to the componentDidUpdate triggered by
// the same Redux change (state.connection.status).
return (
);
}
sendMessageWithoutID: (message: ClientSocketMessageWithoutID) => number =
message => {
const id = this.nextClientMessageID++;
// These conditions all do the same thing and the runtime checks are only
// necessary for Flow
if (message.type === clientSocketMessageTypes.INITIAL) {
this.sendMessage(
({ ...message, id }: ClientInitialClientSocketMessage),
);
} else if (message.type === clientSocketMessageTypes.RESPONSES) {
this.sendMessage(
({ ...message, id }: ClientResponsesClientSocketMessage),
);
} else if (message.type === clientSocketMessageTypes.PING) {
this.sendMessage(({ ...message, id }: PingClientSocketMessage));
} else if (message.type === clientSocketMessageTypes.ACK_UPDATES) {
this.sendMessage(({ ...message, id }: AckUpdatesClientSocketMessage));
} else if (message.type === clientSocketMessageTypes.API_REQUEST) {
this.sendMessage(({ ...message, id }: APIRequestClientSocketMessage));
}
return id;
};
sendMessage(message: ClientClientSocketMessage) {
const socket = this.socket;
invariant(socket, 'should be set');
socket.send(JSON.stringify(message));
}
static messageFromEvent(event: MessageEvent): ?ClientServerSocketMessage {
if (typeof event.data !== 'string') {
console.log('socket received a non-string message');
return null;
}
try {
return JSON.parse(event.data);
} catch (e) {
console.log(e);
return null;
}
}
receiveMessage: (event: MessageEvent) => Promise = async event => {
const message = Socket.messageFromEvent(event);
if (!message) {
return;
}
this.failuresAfterPolicyAcknowledgment = 0;
const { inflightRequests } = this.state;
if (!inflightRequests) {
// inflightRequests can be falsey here if we receive a message after we've
// begun shutting down the socket. It's possible for a React Native
// WebSocket to deliver a message even after close() is called on it. In
// this case the message is probably a PONG, which we can safely ignore.
// If it's not a PONG, it has to be something server-initiated (like
// UPDATES or MESSAGES), since InflightRequests.allRequestsResolvedExcept
// will wait for all responses to client-initiated requests to be
// delivered before closing a socket. UPDATES and MESSAGES are both
// checkpointed on the client, so should be okay to just ignore here and
// redownload them later, probably in an incremental STATE_SYNC.
return;
}
// If we receive any message, that indicates that our connection is healthy,
// so we can reset the ping timeout.
this.resetPing();
inflightRequests.resolveRequestsForMessage(message);
const { status } = this.props.connection;
if (status === 'disconnecting' || status === 'forcedDisconnecting') {
this.finishClosingSocket(
// We do this for Flow
message.responseTo !== undefined ? message.responseTo : null,
);
}
for (const listener of this.listeners) {
listener(message);
}
if (message.type === serverSocketMessageTypes.ERROR) {
const { message: errorMessage, payload } = message;
if (payload) {
console.log(`socket sent error ${errorMessage} with payload`, payload);
} else {
console.log(`socket sent error ${errorMessage}`);
}
if (errorMessage === 'policies_not_accepted') {
this.props.dispatch({
type: forcePolicyAcknowledgmentActionType,
payload,
});
}
} else if (message.type === serverSocketMessageTypes.AUTH_ERROR) {
const { sessionChange } = message;
const cookie = sessionChange ? sessionChange.cookie : this.props.cookie;
this.invalidationRecoveryInProgress = true;
const recoverySessionChange = await fetchNewCookieFromNativeCredentials(
this.props.dispatch,
cookie,
this.props.urlPrefix,
logInActionSources.socketAuthErrorResolutionAttempt,
this.props.getInitialNotificationsEncryptedMessage,
);
if (!recoverySessionChange && sessionChange) {
// This should only happen in the cookieSources.BODY (native) case when
// the resolution attempt failed
const { cookie: newerCookie, currentUserInfo } = sessionChange;
this.props.dispatch({
type: setNewSessionActionType,
payload: {
sessionChange: {
cookieInvalidated: true,
currentUserInfo,
cookie: newerCookie,
},
preRequestUserState: this.initializedWithUserState,
error: null,
logInActionSource:
logInActionSources.socketAuthErrorResolutionAttempt,
},
});
} else if (!recoverySessionChange) {
this.props.dispatchActionPromise(
logOutActionTypes,
this.props.logOut(this.props.preRequestUserState),
);
}
this.invalidationRecoveryInProgress = false;
}
};
addListener: (listener: SocketListener) => void = listener => {
this.listeners.add(listener);
};
removeListener: (listener: SocketListener) => void = listener => {
this.listeners.delete(listener);
};
onClose: () => void = () => {
const { status } = this.props.connection;
this.socket = null;
this.stopPing();
if (this.state.inflightRequests) {
this.state.inflightRequests.rejectAll(new Error('socket closed'));
this.setState({ inflightRequests: null });
}
const handled = this.detectUnsupervisedBackground(true);
if (!handled && status !== 'disconnected') {
this.props.dispatch({
type: updateConnectionStatusActionType,
payload: { status: 'disconnected' },
});
}
};
async sendInitialMessage() {
const { inflightRequests } = this.state;
invariant(
inflightRequests,
'inflightRequests falsey inside sendInitialMessage',
);
const messageID = this.nextClientMessageID++;
const promises = {};
const shouldSendInitialPlatformDetails = !_isEqual(
this.props.lastCommunicatedPlatformDetails,
)(getConfig().platformDetails);
const clientResponses = [];
if (shouldSendInitialPlatformDetails) {
clientResponses.push({
type: serverRequestTypes.PLATFORM_DETAILS,
platformDetails: getConfig().platformDetails,
});
}
const { queuedActivityUpdates } = this.props.connection;
if (queuedActivityUpdates.length > 0) {
clientResponses.push({
type: serverRequestTypes.INITIAL_ACTIVITY_UPDATES,
activityUpdates: queuedActivityUpdates,
});
promises.activityUpdateMessage = inflightRequests.fetchResponse(
messageID,
serverSocketMessageTypes.ACTIVITY_UPDATE_RESPONSE,
);
}
const sessionState = this.props.sessionStateFunc();
const { sessionIdentification } = this.props;
const initialMessage = {
type: clientSocketMessageTypes.INITIAL,
id: messageID,
payload: {
clientResponses,
sessionState,
sessionIdentification,
},
};
this.initializedWithUserState = this.props.preRequestUserState;
this.sendMessage(initialMessage);
promises.stateSyncMessage = inflightRequests.fetchResponse(
messageID,
serverSocketMessageTypes.STATE_SYNC,
);
const { stateSyncMessage, activityUpdateMessage } = await promiseAll(
promises,
);
if (shouldSendInitialPlatformDetails) {
this.props.dispatch({
type: updateLastCommunicatedPlatformDetailsActionType,
- payload: { [this.props.urlPrefix]: getConfig().platformDetails },
+ payload: getConfig().platformDetails,
});
}
if (activityUpdateMessage) {
this.props.dispatch({
type: updateActivityActionTypes.success,
payload: {
activityUpdates: queuedActivityUpdates,
result: activityUpdateMessage.payload,
},
});
}
if (stateSyncMessage.payload.type === stateSyncPayloadTypes.FULL) {
const { sessionID, type, ...actionPayload } = stateSyncMessage.payload;
this.props.dispatch({
type: fullStateSyncActionType,
payload: {
...actionPayload,
calendarQuery: sessionState.calendarQuery,
},
});
if (sessionID !== null && sessionID !== undefined) {
invariant(
this.initializedWithUserState,
'initializedWithUserState should be set when state sync received',
);
this.props.dispatch({
type: setNewSessionActionType,
payload: {
sessionChange: { cookieInvalidated: false, sessionID },
preRequestUserState: this.initializedWithUserState,
error: null,
logInActionSource: undefined,
},
});
}
} else {
const { type, ...actionPayload } = stateSyncMessage.payload;
this.props.dispatch({
type: incrementalStateSyncActionType,
payload: {
...actionPayload,
calendarQuery: sessionState.calendarQuery,
},
});
}
const currentAsOf =
stateSyncMessage.payload.type === stateSyncPayloadTypes.FULL
? stateSyncMessage.payload.updatesCurrentAsOf
: stateSyncMessage.payload.updatesResult.currentAsOf;
this.sendMessageWithoutID({
type: clientSocketMessageTypes.ACK_UPDATES,
payload: { currentAsOf },
});
this.markSocketInitialized();
}
initializeSocket: (retriesLeft?: number) => Promise = async (
retriesLeft = 1,
) => {
try {
await this.sendInitialMessage();
} catch (e) {
if (this.props.noDataAfterPolicyAcknowledgment) {
this.failuresAfterPolicyAcknowledgment++;
} else {
this.failuresAfterPolicyAcknowledgment = 0;
}
if (
this.failuresAfterPolicyAcknowledgment >= 2 &&
this.props.socketCrashLoopRecovery
) {
this.failuresAfterPolicyAcknowledgment = 0;
try {
await this.props.socketCrashLoopRecovery();
} catch (error) {
console.log(error);
this.props.dispatchActionPromise(
logOutActionTypes,
this.props.logOut(this.props.preRequestUserState),
);
}
return;
}
console.log(e);
const { status } = this.props.connection;
if (
e instanceof SocketTimeout ||
e instanceof SocketOffline ||
(status !== 'connecting' && status !== 'reconnecting')
) {
// This indicates that the socket will be closed. Do nothing, since the
// connection status update will trigger a reconnect.
} else if (
retriesLeft === 0 ||
(e instanceof ServerError && e.message !== 'unknown_error')
) {
if (e.message === 'not_logged_in') {
this.props.dispatchActionPromise(
logOutActionTypes,
this.props.logOut(this.props.preRequestUserState),
);
} else if (this.socket) {
this.socket.close();
}
} else {
await this.initializeSocket(retriesLeft - 1);
}
}
};
stopPing() {
if (this.pingTimeoutID) {
clearTimeout(this.pingTimeoutID);
this.pingTimeoutID = null;
}
}
resetPing() {
this.stopPing();
const socket = this.socket;
this.messageLastReceived = Date.now();
this.pingTimeoutID = setTimeout(() => {
if (this.socket === socket) {
this.sendPing();
}
}, pingFrequency);
}
async sendPing() {
if (this.props.connection.status !== 'connected') {
// This generally shouldn't happen because anything that changes the
// connection status should call stopPing(), but it's good to make sure
return;
}
const messageID = this.sendMessageWithoutID({
type: clientSocketMessageTypes.PING,
});
try {
invariant(
this.state.inflightRequests,
'inflightRequests falsey inside sendPing',
);
await this.state.inflightRequests.fetchResponse(
messageID,
serverSocketMessageTypes.PONG,
);
} catch (e) {}
}
setLateResponse: (messageID: number, isLate: boolean) => void = (
messageID,
isLate,
) => {
this.props.dispatch({
type: setLateResponseActionType,
payload: { messageID, isLate },
});
};
cleanUpServerTerminatedSocket() {
if (this.socket && this.socket.readyState < 2) {
this.socket.close();
} else {
this.onClose();
}
}
detectUnsupervisedBackground: (alreadyClosed: boolean) => boolean =
alreadyClosed => {
// On native, sometimes the app is backgrounded without the proper
// callbacks getting triggered. This leaves us in an incorrect state for
// two reasons:
// (1) The connection is still considered to be active, causing API
// requests to be processed via socket and failing.
// (2) We rely on flipping foreground state in Redux to detect activity
// changes, and thus won't think we need to update activity.
if (
this.props.connection.status !== 'connected' ||
!this.messageLastReceived ||
this.messageLastReceived + serverRequestSocketTimeout >= Date.now() ||
(actionLogger.mostRecentActionTime &&
actionLogger.mostRecentActionTime + 3000 < Date.now())
) {
return false;
}
if (!alreadyClosed) {
this.cleanUpServerTerminatedSocket();
}
this.props.dispatch({
type: unsupervisedBackgroundActionType,
payload: null,
});
return true;
};
}
export default Socket;
diff --git a/lib/types/device-types.js b/lib/types/device-types.js
index e681a04d7..771e9185f 100644
--- a/lib/types/device-types.js
+++ b/lib/types/device-types.js
@@ -1,50 +1,46 @@
// @flow
import invariant from 'invariant';
import { values } from '../utils/objects.js';
const deviceTypesObj = Object.freeze({
ios: 'ios',
android: 'android',
});
export type DeviceType = $Values;
export type Platform = DeviceType | 'web' | 'windows' | 'macos';
export const deviceTypes: $ReadOnlyArray = values(deviceTypesObj);
export function isDeviceType(platform: ?string): boolean {
return platform === 'ios' || platform === 'android';
}
export function assertDeviceType(deviceType: ?string): DeviceType {
invariant(
deviceType === 'ios' || deviceType === 'android',
'string is not DeviceType enum',
);
return deviceType;
}
export function isWebPlatform(platform: ?string): boolean {
return platform === 'web' || platform === 'windows' || platform === 'macos';
}
export type DeviceTokenUpdateRequest = {
+deviceToken: string,
+deviceType?: DeviceType,
+platformDetails?: PlatformDetails,
};
export type PlatformDetails = {
+platform: Platform,
+codeVersion?: number,
+stateVersion?: number,
};
export type VersionResponse = {
+codeVersion: number,
};
-
-export type LastCommunicatedPlatformDetails = {
- +[urlPrefix: string]: PlatformDetails,
-};
diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
index afef7c14a..09caf1f69 100644
--- a/lib/types/redux-types.js
+++ b/lib/types/redux-types.js
@@ -1,1215 +1,1212 @@
// @flow
import type {
LogOutResult,
LogInStartingPayload,
LogInResult,
RegisterResult,
DefaultNotificationPayload,
} from './account-types.js';
import type {
ActivityUpdateSuccessPayload,
QueueActivityUpdatesPayload,
SetThreadUnreadStatusPayload,
} from './activity-types.js';
import type {
UpdateUserAvatarRequest,
UpdateUserAvatarResponse,
} from './avatar-types.js';
import type { CryptoStore } from './crypto-types.js';
-import type {
- VersionResponse,
- LastCommunicatedPlatformDetails,
-} from './device-types.js';
+import type { VersionResponse, PlatformDetails } from './device-types.js';
import type { ClientDBDraftInfo, DraftStore } from './draft-types.js';
import type { EnabledApps, SupportedApps } from './enabled-apps.js';
import type {
RawEntryInfo,
EntryStore,
SaveEntryPayload,
CreateEntryPayload,
DeleteEntryResult,
RestoreEntryPayload,
FetchEntryInfosResult,
CalendarQueryUpdateResult,
CalendarQueryUpdateStartingPayload,
CalendarQuery,
} from './entry-types.js';
import type {
CalendarFilter,
CalendarThreadFilter,
SetCalendarDeletedFilterPayload,
} from './filter-types.js';
import type { KeyserverStore } from './keyserver-types.js';
import type { LifecycleState } from './lifecycle-state-types.js';
import type {
FetchInviteLinksResponse,
InviteLink,
InviteLinksStore,
InviteLinkVerificationResponse,
DisableInviteLinkPayload,
} from './link-types.js';
import type { LoadingStatus, LoadingInfo } from './loading-types.js';
import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
import type { MessageReportCreationResult } from './message-report-types.js';
import type {
MessageStore,
RawMultimediaMessageInfo,
FetchMessageInfosPayload,
SendMessagePayload,
EditMessagePayload,
SaveMessagesPayload,
NewMessagesPayload,
MessageStorePrunePayload,
LocallyComposedMessageInfo,
ClientDBMessageInfo,
SimpleMessagesPayload,
ClientDBThreadMessageInfo,
FetchPinnedMessagesResult,
SearchMessagesResponse,
} from './message-types.js';
import type { RawReactionMessageInfo } from './messages/reaction.js';
import type { RawTextMessageInfo } from './messages/text.js';
import type { BaseNavInfo } from './nav-types.js';
import {
type ForcePolicyAcknowledgmentPayload,
type PolicyAcknowledgmentPayload,
type UserPolicies,
} from './policy-types.js';
import type { RelationshipErrors } from './relationship-types.js';
import type {
EnabledReports,
ClearDeliveredReportsPayload,
QueueReportsPayload,
ReportStore,
ClientReportCreationRequest,
} from './report-types.js';
import type {
ProcessServerRequestsPayload,
GetOlmSessionInitializationDataResponse,
} from './request-types.js';
import type {
UserSearchResult,
ExactUserSearchResult,
} from './search-types.js';
import type { SetSessionPayload } from './session-types.js';
import type {
StateSyncFullActionPayload,
StateSyncIncrementalActionPayload,
UpdateConnectionStatusPayload,
SetLateResponsePayload,
UpdateDisconnectedBarPayload,
} from './socket-types.js';
import type { SubscriptionUpdateResult } from './subscription-types.js';
import type {
ThreadStore,
ChangeThreadSettingsPayload,
LeaveThreadPayload,
NewThreadResult,
ThreadJoinPayload,
ToggleMessagePinResult,
RoleModificationPayload,
RoleDeletionPayload,
} from './thread-types.js';
import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
import type { CurrentUserInfo, UserStore } from './user-types.js';
import type { Shape } from '../types/core.js';
import type { NotifPermissionAlertInfo } from '../utils/push-alerts.js';
export type BaseAppState = {
+navInfo: NavInfo,
+currentUserInfo: ?CurrentUserInfo,
+draftStore: DraftStore,
+entryStore: EntryStore,
+threadStore: ThreadStore,
+userStore: UserStore,
+messageStore: MessageStore,
+loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
+calendarFilters: $ReadOnlyArray,
+notifPermissionAlertInfo: NotifPermissionAlertInfo,
+actualizedCalendarQuery: CalendarQuery,
+watchedThreadIDs: $ReadOnlyArray,
+lifecycleState: LifecycleState,
+enabledApps: EnabledApps,
+reportStore: ReportStore,
+nextLocalID: number,
+dataLoaded: boolean,
+userPolicies: UserPolicies,
+deviceToken: ?string,
+commServicesAccessToken: ?string,
+inviteLinksStore: InviteLinksStore,
- +lastCommunicatedPlatformDetails: LastCommunicatedPlatformDetails,
+ +lastCommunicatedPlatformDetails: ?PlatformDetails,
+keyserverStore: KeyserverStore,
...
};
export type NativeAppState = BaseAppState<>;
export type WebAppState = BaseAppState<> & {
+cryptoStore: CryptoStore,
+pushApiPublicKey: ?string,
...
};
export type AppState = NativeAppState | WebAppState;
export type BaseAction =
| {
+type: '@@redux/INIT',
+payload?: void,
}
| {
+type: 'FETCH_ENTRIES_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_ENTRIES_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_ENTRIES_SUCCESS',
+payload: FetchEntryInfosResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LOG_OUT_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LOG_OUT_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LOG_OUT_SUCCESS',
+payload: LogOutResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_ACCOUNT_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_ACCOUNT_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_ACCOUNT_SUCCESS',
+payload: LogOutResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CREATE_LOCAL_ENTRY',
+payload: RawEntryInfo,
}
| {
+type: 'CREATE_ENTRY_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CREATE_ENTRY_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CREATE_ENTRY_SUCCESS',
+payload: CreateEntryPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SAVE_ENTRY_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SAVE_ENTRY_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SAVE_ENTRY_SUCCESS',
+payload: SaveEntryPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CONCURRENT_MODIFICATION_RESET',
+payload: {
+id: string,
+dbText: string,
},
}
| {
+type: 'DELETE_ENTRY_STARTED',
+loadingInfo: LoadingInfo,
+payload: {
+localID: ?string,
+serverID: ?string,
},
}
| {
+type: 'DELETE_ENTRY_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_ENTRY_SUCCESS',
+payload: ?DeleteEntryResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LOG_IN_STARTED',
+loadingInfo: LoadingInfo,
+payload: LogInStartingPayload,
}
| {
+type: 'LOG_IN_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LOG_IN_SUCCESS',
+payload: LogInResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'REGISTER_STARTED',
+loadingInfo: LoadingInfo,
+payload: LogInStartingPayload,
}
| {
+type: 'REGISTER_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'REGISTER_SUCCESS',
+payload: RegisterResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_USER_PASSWORD_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_USER_PASSWORD_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_USER_PASSWORD_SUCCESS',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_THREAD_SETTINGS_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_THREAD_SETTINGS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
+payload: ChangeThreadSettingsPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_THREAD_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_THREAD_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_THREAD_SUCCESS',
+payload: LeaveThreadPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'NEW_THREAD_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'NEW_THREAD_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'NEW_THREAD_SUCCESS',
+payload: NewThreadResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'REMOVE_USERS_FROM_THREAD_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'REMOVE_USERS_FROM_THREAD_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
+payload: ChangeThreadSettingsPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
+payload: ChangeThreadSettingsPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
+payload: {
+entryID: string,
+text: string,
+deleted: boolean,
},
+loadingInfo: LoadingInfo,
}
| {
+type: 'RESTORE_ENTRY_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'RESTORE_ENTRY_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'RESTORE_ENTRY_SUCCESS',
+payload: RestoreEntryPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'JOIN_THREAD_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'JOIN_THREAD_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'JOIN_THREAD_SUCCESS',
+payload: ThreadJoinPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LEAVE_THREAD_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LEAVE_THREAD_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'LEAVE_THREAD_SUCCESS',
+payload: LeaveThreadPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_NEW_SESSION',
+payload: SetSessionPayload,
}
| {
+type: 'persist/REHYDRATE',
+payload: ?BaseAppState<>,
}
| {
+type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
+payload: FetchMessageInfosPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
+payload: FetchMessageInfosPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
+payload: SimpleMessagesPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_TEXT_MESSAGE_STARTED',
+loadingInfo?: LoadingInfo,
+payload: RawTextMessageInfo,
}
| {
+type: 'SEND_TEXT_MESSAGE_FAILED',
+error: true,
+payload: Error & {
+localID: string,
+threadID: string,
},
+loadingInfo?: LoadingInfo,
}
| {
+type: 'SEND_TEXT_MESSAGE_SUCCESS',
+payload: SendMessagePayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
+loadingInfo?: LoadingInfo,
+payload: RawMultimediaMessageInfo,
}
| {
+type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
+error: true,
+payload: Error & {
+localID: string,
+threadID: string,
},
+loadingInfo?: LoadingInfo,
}
| {
+type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
+payload: SendMessagePayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REACTION_MESSAGE_STARTED',
+loadingInfo?: LoadingInfo,
+payload: RawReactionMessageInfo,
}
| {
+type: 'SEND_REACTION_MESSAGE_FAILED',
+error: true,
+payload: Error & {
+localID: string,
+threadID: string,
+targetMessageID: string,
+reaction: string,
+action: string,
},
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REACTION_MESSAGE_SUCCESS',
+payload: SendMessagePayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEARCH_USERS_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEARCH_USERS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEARCH_USERS_SUCCESS',
+payload: UserSearchResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'EXACT_SEARCH_USER_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'EXACT_SEARCH_USER_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'EXACT_SEARCH_USER_SUCCESS',
+payload: ExactUserSearchResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_DRAFT',
+payload: {
+key: string,
+text: string,
},
}
| {
+type: 'MOVE_DRAFT',
+payload: {
+oldKey: string,
+newKey: string,
},
}
| {
+type: 'SET_CLIENT_DB_STORE',
+payload: {
+currentUserID: ?string,
+drafts: $ReadOnlyArray,
+messages: ?$ReadOnlyArray,
+threadStore: ?ThreadStore,
+messageStoreThreads: ?$ReadOnlyArray,
+reports: ?$ReadOnlyArray,
},
}
| {
+type: 'UPDATE_ACTIVITY_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_ACTIVITY_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_ACTIVITY_SUCCESS',
+payload: ActivityUpdateSuccessPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_DEVICE_TOKEN_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_DEVICE_TOKEN_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_DEVICE_TOKEN_SUCCESS',
+payload: ?string,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REPORT_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REPORT_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REPORT_SUCCESS',
+payload?: ClearDeliveredReportsPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REPORTS_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REPORTS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_REPORTS_SUCCESS',
+payload?: ClearDeliveredReportsPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'QUEUE_REPORTS',
+payload: QueueReportsPayload,
}
| {
+type: 'SET_URL_PREFIX',
+payload: string,
}
| {
+type: 'SAVE_MESSAGES',
+payload: SaveMessagesPayload,
}
| {
+type: 'UPDATE_CALENDAR_THREAD_FILTER',
+payload: CalendarThreadFilter,
}
| {
+type: 'CLEAR_CALENDAR_THREAD_FILTER',
+payload?: void,
}
| {
+type: 'SET_CALENDAR_DELETED_FILTER',
+payload: SetCalendarDeletedFilterPayload,
}
| {
+type: 'UPDATE_SUBSCRIPTION_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_SUBSCRIPTION_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_SUBSCRIPTION_SUCCESS',
+payload: SubscriptionUpdateResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_CALENDAR_QUERY_STARTED',
+loadingInfo: LoadingInfo,
+payload?: CalendarQueryUpdateStartingPayload,
}
| {
+type: 'UPDATE_CALENDAR_QUERY_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
+payload: CalendarQueryUpdateResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FULL_STATE_SYNC',
+payload: StateSyncFullActionPayload,
}
| {
+type: 'INCREMENTAL_STATE_SYNC',
+payload: StateSyncIncrementalActionPayload,
}
| {
+type: 'PROCESS_SERVER_REQUESTS',
+payload: ProcessServerRequestsPayload,
}
| {
+type: 'UPDATE_CONNECTION_STATUS',
+payload: UpdateConnectionStatusPayload,
}
| {
+type: 'QUEUE_ACTIVITY_UPDATES',
+payload: QueueActivityUpdatesPayload,
}
| {
+type: 'UNSUPERVISED_BACKGROUND',
+payload?: void,
}
| {
+type: 'UPDATE_LIFECYCLE_STATE',
+payload: LifecycleState,
}
| {
+type: 'ENABLE_APP',
+payload: SupportedApps,
}
| {
+type: 'DISABLE_APP',
+payload: SupportedApps,
}
| {
+type: 'UPDATE_REPORTS_ENABLED',
+payload: Shape,
}
| {
+type: 'PROCESS_UPDATES',
+payload: ClientUpdatesResultWithUserInfos,
}
| {
+type: 'PROCESS_MESSAGES',
+payload: NewMessagesPayload,
}
| {
+type: 'MESSAGE_STORE_PRUNE',
+payload: MessageStorePrunePayload,
}
| {
+type: 'SET_LATE_RESPONSE',
+payload: SetLateResponsePayload,
}
| {
+type: 'UPDATE_DISCONNECTED_BAR',
+payload: UpdateDisconnectedBarPayload,
}
| {
+type: 'REQUEST_ACCESS_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'REQUEST_ACCESS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'REQUEST_ACCESS_SUCCESS',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
+payload: UpdateMultimediaMessageMediaPayload,
}
| {
+type: 'CREATE_LOCAL_MESSAGE',
+payload: LocallyComposedMessageInfo,
}
| {
+type: 'UPDATE_RELATIONSHIPS_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_RELATIONSHIPS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_RELATIONSHIPS_SUCCESS',
+payload: RelationshipErrors,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_THREAD_UNREAD_STATUS_STARTED',
+payload: {
+threadID: string,
+unread: boolean,
},
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_THREAD_UNREAD_STATUS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
+payload: SetThreadUnreadStatusPayload,
}
| {
+type: 'SET_USER_SETTINGS_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_USER_SETTINGS_SUCCESS',
+payload: DefaultNotificationPayload,
}
| {
+type: 'SET_USER_SETTINGS_FAILED',
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_MESSAGE_REPORT_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_MESSAGE_REPORT_SUCCESS',
+payload: MessageReportCreationResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_MESSAGE_REPORT_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FORCE_POLICY_ACKNOWLEDGMENT',
+payload: ForcePolicyAcknowledgmentPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'POLICY_ACKNOWLEDGMENT_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
+payload: PolicyAcknowledgmentPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'POLICY_ACKNOWLEDGMENT_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'GET_SIWE_NONCE_STARTED',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'GET_SIWE_NONCE_SUCCESS',
+payload?: void,
+loadingInfo: LoadingInfo,
}
| {
+type: 'GET_SIWE_NONCE_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SIWE_AUTH_STARTED',
+payload: LogInStartingPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SIWE_AUTH_SUCCESS',
+payload: LogInResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SIWE_AUTH_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'RECORD_NOTIF_PERMISSION_ALERT',
+payload: { +time: number },
}
| {
+type: 'UPDATE_USER_AVATAR_STARTED',
+payload: UpdateUserAvatarRequest,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_USER_AVATAR_SUCCESS',
+payload: UpdateUserAvatarResponse,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_USER_AVATAR_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_EDIT_MESSAGE_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'SEND_EDIT_MESSAGE_SUCCESS',
+payload: EditMessagePayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEND_EDIT_MESSAGE_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'TOGGLE_MESSAGE_PIN_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
+payload: ToggleMessagePinResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'TOGGLE_MESSAGE_PIN_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_PINNED_MESSAGES_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'FETCH_PINNED_MESSAGES_SUCCESS',
+payload: FetchPinnedMessagesResult,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_PINNED_MESSAGES_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'VERIFY_INVITE_LINK_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'VERIFY_INVITE_LINK_SUCCESS',
+payload: InviteLinkVerificationResponse,
+loadingInfo: LoadingInfo,
}
| {
+type: 'VERIFY_INVITE_LINK_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
+payload: FetchInviteLinksResponse,
+loadingInfo: LoadingInfo,
}
| {
+type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
+payload: string,
}
| {
+type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
+payload: void,
}
| {
+type: 'UPDATE_CHAT_COMMUNITY_FILTER',
+payload: string,
}
| {
+type: 'CLEAR_CHAT_COMMUNITY_FILTER',
+payload: void,
}
| {
+type: 'SEARCH_MESSAGES_STARTED',
+payload: void,
+loadingInfo?: LoadingInfo,
}
| {
+type: 'SEARCH_MESSAGES_SUCCESS',
+payload: SearchMessagesResponse,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SEARCH_MESSAGES_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
+payload: InviteLink,
+loadingInfo: LoadingInfo,
}
| {
+type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DISABLE_INVITE_LINK_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'DISABLE_INVITE_LINK_SUCCESS',
+payload: DisableInviteLinkPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DISABLE_INVITE_LINK_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
+payload: GetOlmSessionInitializationDataResponse,
+loadingInfo: LoadingInfo,
}
| {
+type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'SET_DATA_LOADED',
+payload: {
+dataLoaded: boolean,
},
}
| {
+type: 'GET_VERSION_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'GET_VERSION_SUCCESS',
+payload: VersionResponse,
+loadingInfo: LoadingInfo,
}
| {
+type: 'GET_VERSION_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
- +payload: LastCommunicatedPlatformDetails,
+ +payload: PlatformDetails,
}
| { +type: 'RESET_USER_STATE', +payload?: void }
| {
+type: 'MODIFY_COMMUNITY_ROLE_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
+payload: RoleModificationPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'MODIFY_COMMUNITY_ROLE_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_COMMUNITY_ROLE_STARTED',
+loadingInfo?: LoadingInfo,
+payload?: void,
}
| {
+type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
+payload: RoleDeletionPayload,
+loadingInfo: LoadingInfo,
}
| {
+type: 'DELETE_COMMUNITY_ROLE_FAILED',
+error: true,
+payload: Error,
+loadingInfo: LoadingInfo,
};
export type ActionPayload = ?(Object | Array<*> | $ReadOnlyArray<*> | string);
export type SuperAction = {
type: string,
payload?: ActionPayload,
loadingInfo?: LoadingInfo,
error?: boolean,
};
type ThunkedAction = (dispatch: Dispatch) => void;
export type PromisedAction = (dispatch: Dispatch) => Promise;
export type Dispatch = ((promisedAction: PromisedAction) => Promise) &
((thunkedAction: ThunkedAction) => void) &
((action: SuperAction) => boolean);
// This is lifted from redux-persist/lib/constants.js
// I don't want to add redux-persist to the web/server bundles...
// import { REHYDRATE } from 'redux-persist';
export const rehydrateActionType = 'persist/REHYDRATE';
diff --git a/lib/utils/action-utils.js b/lib/utils/action-utils.js
index 81aac26a9..df8d6edf0 100644
--- a/lib/utils/action-utils.js
+++ b/lib/utils/action-utils.js
@@ -1,462 +1,462 @@
// @flow
import invariant from 'invariant';
import _memoize from 'lodash/memoize.js';
import * as React from 'react';
import { useSelector, useDispatch } from 'react-redux';
import { createSelector } from 'reselect';
import callServerEndpoint from './call-server-endpoint.js';
import type {
CallServerEndpoint,
CallServerEndpointOptions,
} from './call-server-endpoint.js';
import { getConfig } from './config.js';
import { serverCallStateSelector } from '../selectors/server-calls.js';
import {
logInActionSources,
type LogInActionSource,
type LogInStartingPayload,
type LogInResult,
} from '../types/account-types.js';
-import type { LastCommunicatedPlatformDetails } from '../types/device-types.js';
+import type { PlatformDetails } from '../types/device-types.js';
import type { Endpoint, SocketAPIHandler } from '../types/endpoints.js';
import type { LoadingOptions, LoadingInfo } from '../types/loading-types.js';
import type {
ActionPayload,
Dispatch,
PromisedAction,
BaseAction,
} from '../types/redux-types.js';
import type {
ClientSessionChange,
PreRequestUserState,
} from '../types/session-types.js';
import type { ConnectionStatus } from '../types/socket-types.js';
import type { CurrentUserInfo } from '../types/user-types.js';
let nextPromiseIndex = 0;
export type ActionTypes<
STARTED_ACTION_TYPE: string,
SUCCESS_ACTION_TYPE: string,
FAILED_ACTION_TYPE: string,
> = {
started: STARTED_ACTION_TYPE,
success: SUCCESS_ACTION_TYPE,
failed: FAILED_ACTION_TYPE,
};
function wrapActionPromise<
STARTED_ACTION_TYPE: string,
STARTED_PAYLOAD: ActionPayload,
SUCCESS_ACTION_TYPE: string,
SUCCESS_PAYLOAD: ActionPayload,
FAILED_ACTION_TYPE: string,
>(
actionTypes: ActionTypes<
STARTED_ACTION_TYPE,
SUCCESS_ACTION_TYPE,
FAILED_ACTION_TYPE,
>,
promise: Promise,
loadingOptions: ?LoadingOptions,
startingPayload: ?STARTED_PAYLOAD,
): PromisedAction {
const loadingInfo: LoadingInfo = {
fetchIndex: nextPromiseIndex++,
trackMultipleRequests: !!loadingOptions?.trackMultipleRequests,
customKeyName: loadingOptions?.customKeyName || null,
};
return async (dispatch: Dispatch): Promise => {
const startAction = startingPayload
? {
type: (actionTypes.started: STARTED_ACTION_TYPE),
loadingInfo,
payload: (startingPayload: STARTED_PAYLOAD),
}
: {
type: (actionTypes.started: STARTED_ACTION_TYPE),
loadingInfo,
};
dispatch(startAction);
try {
const result = await promise;
dispatch({
type: (actionTypes.success: SUCCESS_ACTION_TYPE),
payload: (result: SUCCESS_PAYLOAD),
loadingInfo,
});
} catch (e) {
console.log(e);
dispatch({
type: (actionTypes.failed: FAILED_ACTION_TYPE),
error: true,
payload: (e: Error),
loadingInfo,
});
}
};
}
export type DispatchActionPromise = <
STARTED: BaseAction,
SUCCESS: BaseAction,
FAILED: BaseAction,
>(
actionTypes: ActionTypes<
$PropertyType,
$PropertyType,
$PropertyType,
>,
promise: Promise<$PropertyType>,
loadingOptions?: LoadingOptions,
startingPayload?: $PropertyType,
) => Promise;
function useDispatchActionPromise(): DispatchActionPromise {
const dispatch = useDispatch();
return React.useMemo(() => createDispatchActionPromise(dispatch), [dispatch]);
}
function createDispatchActionPromise(dispatch: Dispatch) {
const dispatchActionPromise = function <
STARTED: BaseAction,
SUCCESS: BaseAction,
FAILED: BaseAction,
>(
actionTypes: ActionTypes<
$PropertyType,
$PropertyType,
$PropertyType,
>,
promise: Promise<$PropertyType>,
loadingOptions?: LoadingOptions,
startingPayload?: $PropertyType,
): Promise {
return dispatch(
wrapActionPromise(actionTypes, promise, loadingOptions, startingPayload),
);
};
return dispatchActionPromise;
}
export type DispatchFunctions = {
+dispatch: Dispatch,
+dispatchActionPromise: DispatchActionPromise,
};
let currentlyWaitingForNewCookie = false;
let serverEndpointCallsWaitingForNewCookie: ((
callServerEndpoint: ?CallServerEndpoint,
) => void)[] = [];
export type DispatchRecoveryAttempt = (
actionTypes: ActionTypes<'LOG_IN_STARTED', 'LOG_IN_SUCCESS', 'LOG_IN_FAILED'>,
promise: Promise,
startingPayload: LogInStartingPayload,
) => Promise;
const setNewSessionActionType = 'SET_NEW_SESSION';
function setNewSession(
dispatch: Dispatch,
sessionChange: ClientSessionChange,
preRequestUserState: ?PreRequestUserState,
error: ?string,
logInActionSource: ?LogInActionSource,
) {
dispatch({
type: setNewSessionActionType,
payload: { sessionChange, preRequestUserState, error, logInActionSource },
});
}
// This function calls resolveInvalidatedCookie, which dispatchs a log in action
// using the native credentials. Note that we never actually specify a sessionID
// here, on the assumption that only native clients will call this. (Native
// clients don't specify a sessionID, indicating to the server that it should
// use the cookieID as the sessionID.)
async function fetchNewCookieFromNativeCredentials(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
logInActionSource: LogInActionSource,
getInitialNotificationsEncryptedMessage?: () => Promise,
): Promise {
const resolveInvalidatedCookie = getConfig().resolveInvalidatedCookie;
if (!resolveInvalidatedCookie) {
return null;
}
let newSessionChange = null;
let callServerEndpointCallback = null;
const boundCallServerEndpoint = async (
endpoint: Endpoint,
data: { [key: string]: mixed },
options?: ?CallServerEndpointOptions,
) => {
const innerBoundSetNewSession = (
sessionChange: ClientSessionChange,
error: ?string,
) => {
newSessionChange = sessionChange;
setNewSession(dispatch, sessionChange, null, error, logInActionSource);
};
try {
const result = await callServerEndpoint(
cookie,
innerBoundSetNewSession,
() => new Promise(r => r(null)),
() => new Promise(r => r(null)),
urlPrefix,
null,
'disconnected',
null,
null,
endpoint,
data,
dispatch,
options,
);
if (callServerEndpointCallback) {
callServerEndpointCallback(!!newSessionChange);
}
return result;
} catch (e) {
if (callServerEndpointCallback) {
callServerEndpointCallback(!!newSessionChange);
}
throw e;
}
};
const dispatchRecoveryAttempt = (
actionTypes: ActionTypes<
'LOG_IN_STARTED',
'LOG_IN_SUCCESS',
'LOG_IN_FAILED',
>,
promise: Promise,
inputStartingPayload: LogInStartingPayload,
) => {
const startingPayload = { ...inputStartingPayload, logInActionSource };
dispatch(wrapActionPromise(actionTypes, promise, null, startingPayload));
return new Promise(r => (callServerEndpointCallback = r));
};
await resolveInvalidatedCookie(
boundCallServerEndpoint,
dispatchRecoveryAttempt,
logInActionSource,
getInitialNotificationsEncryptedMessage,
);
return newSessionChange;
}
// Third param is optional and gets called with newCookie if we get a new cookie
// Necessary to propagate cookie in cookieInvalidationRecovery below
function bindCookieAndUtilsIntoCallServerEndpoint(
params: BindServerCallsParams,
): CallServerEndpoint {
const {
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
} = params;
const loggedIn = !!(currentUserInfo && !currentUserInfo.anonymous && true);
const boundSetNewSession = (
sessionChange: ClientSessionChange,
error: ?string,
) =>
setNewSession(
dispatch,
sessionChange,
{ currentUserInfo, cookie, sessionID },
error,
undefined,
);
// This function gets called before callServerEndpoint sends a request,
// to make sure that we're not in the middle of trying to recover
// an invalidated cookie
const waitIfCookieInvalidated = () => {
if (!getConfig().resolveInvalidatedCookie) {
// If there is no resolveInvalidatedCookie function, just let the caller
// callServerEndpoint instance continue
return Promise.resolve(null);
}
if (!currentlyWaitingForNewCookie) {
// Our cookie seems to be valid
return Promise.resolve(null);
}
// Wait to run until we get our new cookie
return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
};
// This function is a helper for the next function defined below
const attemptToResolveInvalidation = async (
sessionChange: ClientSessionChange,
) => {
const newAnonymousCookie = sessionChange.cookie;
const newSessionChange = await fetchNewCookieFromNativeCredentials(
dispatch,
newAnonymousCookie,
urlPrefix,
logInActionSources.cookieInvalidationResolutionAttempt,
);
currentlyWaitingForNewCookie = false;
const currentWaitingCalls = serverEndpointCallsWaitingForNewCookie;
serverEndpointCallsWaitingForNewCookie = [];
const newCallServerEndpoint = newSessionChange
? bindCookieAndUtilsIntoCallServerEndpoint({
...params,
cookie: newSessionChange.cookie,
sessionID: newSessionChange.sessionID,
currentUserInfo: newSessionChange.currentUserInfo,
})
: null;
for (const func of currentWaitingCalls) {
func(newCallServerEndpoint);
}
return newCallServerEndpoint;
};
// If this function is called, callServerEndpoint got a response invalidating
// its cookie, and is wondering if it should just like... give up?
// Or if there's a chance at redemption
const cookieInvalidationRecovery = (sessionChange: ClientSessionChange) => {
if (!getConfig().resolveInvalidatedCookie) {
// If there is no resolveInvalidatedCookie function, just let the caller
// callServerEndpoint instance continue
return Promise.resolve(null);
}
if (!loggedIn) {
// We don't want to attempt any use native credentials of a logged out
// user to log-in after a cookieInvalidation while logged out
return Promise.resolve(null);
}
if (currentlyWaitingForNewCookie) {
return new Promise(r => serverEndpointCallsWaitingForNewCookie.push(r));
}
currentlyWaitingForNewCookie = true;
return attemptToResolveInvalidation(sessionChange);
};
return (
endpoint: Endpoint,
data: Object,
options?: ?CallServerEndpointOptions,
) =>
callServerEndpoint(
cookie,
boundSetNewSession,
waitIfCookieInvalidated,
cookieInvalidationRecovery,
urlPrefix,
sessionID,
connectionStatus,
lastCommunicatedPlatformDetails,
socketAPIHandler,
endpoint,
data,
dispatch,
options,
);
}
export type ActionFunc = (callServerEndpoint: CallServerEndpoint) => F;
export type BindServerCall = (serverCall: ActionFunc) => F;
export type BindServerCallsParams = {
+dispatch: Dispatch,
+cookie: ?string,
+urlPrefix: string,
+sessionID: ?string,
+currentUserInfo: ?CurrentUserInfo,
+connectionStatus: ConnectionStatus,
- +lastCommunicatedPlatformDetails: LastCommunicatedPlatformDetails,
+ +lastCommunicatedPlatformDetails: ?PlatformDetails,
};
// All server calls needs to include some information from the Redux state
// (namely, the cookie). This information is used deep in the server call,
// at the point where callServerEndpoint is called. We don't want to bother
// propagating the cookie (and any future config info that callServerEndpoint
// needs) through to the server calls so they can pass it to callServerEndpoint.
// Instead, we "curry" the cookie onto callServerEndpoint within react-redux's
// connect's mapStateToProps function, and then pass that "bound"
// callServerEndpoint that no longer needs the cookie as a parameter on to
// the server call.
const baseCreateBoundServerCallsSelector = (
actionFunc: ActionFunc,
): (BindServerCallsParams => F) =>
createSelector(
(state: BindServerCallsParams) => state.dispatch,
(state: BindServerCallsParams) => state.cookie,
(state: BindServerCallsParams) => state.urlPrefix,
(state: BindServerCallsParams) => state.sessionID,
(state: BindServerCallsParams) => state.currentUserInfo,
(state: BindServerCallsParams) => state.connectionStatus,
(state: BindServerCallsParams) => state.lastCommunicatedPlatformDetails,
(
dispatch: Dispatch,
cookie: ?string,
urlPrefix: string,
sessionID: ?string,
currentUserInfo: ?CurrentUserInfo,
connectionStatus: ConnectionStatus,
- lastCommunicatedPlatformDetails: LastCommunicatedPlatformDetails,
+ lastCommunicatedPlatformDetails: ?PlatformDetails,
) => {
const boundCallServerEndpoint = bindCookieAndUtilsIntoCallServerEndpoint({
dispatch,
cookie,
urlPrefix,
sessionID,
currentUserInfo,
connectionStatus,
lastCommunicatedPlatformDetails,
});
return actionFunc(boundCallServerEndpoint);
},
);
type CreateBoundServerCallsSelectorType = (
ActionFunc,
) => BindServerCallsParams => F;
const createBoundServerCallsSelector: CreateBoundServerCallsSelectorType =
(_memoize(baseCreateBoundServerCallsSelector): any);
function useServerCall(
serverCall: ActionFunc,
paramOverride?: ?$Shape,
): F {
const dispatch = useDispatch();
const serverCallState = useSelector(serverCallStateSelector);
return React.useMemo(() => {
const { urlPrefix, connectionStatus } = serverCallState;
invariant(
!!urlPrefix && !!connectionStatus,
'keyserver missing from keyserverStore',
);
return createBoundServerCallsSelector(serverCall)({
...serverCallState,
urlPrefix,
connectionStatus,
dispatch,
...paramOverride,
});
}, [serverCall, serverCallState, dispatch, paramOverride]);
}
let socketAPIHandler: ?SocketAPIHandler = null;
function registerActiveSocket(passedSocketAPIHandler: ?SocketAPIHandler) {
socketAPIHandler = passedSocketAPIHandler;
}
export {
useDispatchActionPromise,
setNewSessionActionType,
fetchNewCookieFromNativeCredentials,
createBoundServerCallsSelector,
registerActiveSocket,
useServerCall,
};
diff --git a/lib/utils/call-server-endpoint.js b/lib/utils/call-server-endpoint.js
index 0ad551d1e..62013b565 100644
--- a/lib/utils/call-server-endpoint.js
+++ b/lib/utils/call-server-endpoint.js
@@ -1,249 +1,242 @@
// @flow
import _isEqual from 'lodash/fp/isEqual.js';
import { getConfig } from './config.js';
import {
ServerError,
FetchTimeout,
SocketOffline,
SocketTimeout,
} from './errors.js';
import sleep from './sleep.js';
import { uploadBlob, type UploadBlob } from './upload-blob.js';
import { updateLastCommunicatedPlatformDetailsActionType } from '../actions/device-actions.js';
import { callServerEndpointTimeout } from '../shared/timeouts.js';
import type { Shape } from '../types/core.js';
-import type {
- PlatformDetails,
- LastCommunicatedPlatformDetails,
-} from '../types/device-types.js';
+import type { PlatformDetails } from '../types/device-types.js';
import {
type Endpoint,
type SocketAPIHandler,
endpointIsSocketPreferred,
endpointIsSocketOnly,
} from '../types/endpoints.js';
import { forcePolicyAcknowledgmentActionType } from '../types/policy-types.js';
import type { Dispatch } from '../types/redux-types.js';
import type {
ServerSessionChange,
ClientSessionChange,
} from '../types/session-types.js';
import type { ConnectionStatus } from '../types/socket-types';
import type { CurrentUserInfo } from '../types/user-types.js';
export type CallServerEndpointOptions = Shape<{
// null timeout means no timeout, which is the default for uploadBlob
+timeout: ?number, // in milliseconds
// getResultInfo will be called right before callServerEndpoint successfully
// resolves and includes additional information about the request
+getResultInfo: (resultInfo: CallServerEndpointResultInfo) => mixed,
+blobUpload: boolean | UploadBlob,
// the rest (onProgress, abortHandler) only work with blobUpload
+onProgress: (percent: number) => void,
// abortHandler will receive an abort function once the upload starts
+abortHandler: (abort: () => void) => void,
// Overrides urlPrefix in Redux
+urlPrefixOverride: string,
}>;
export type CallServerEndpointResultInfoInterface = 'socket' | 'REST';
export type CallServerEndpointResultInfo = {
+interface: CallServerEndpointResultInfoInterface,
};
export type CallServerEndpointResponse = Shape<{
+cookieChange: ServerSessionChange,
+currentUserInfo: CurrentUserInfo,
+error: string,
+payload: Object,
}>;
// You'll notice that this is not the type of the callServerEndpoint
// function below. This is because the first several parameters to that
// function get bound in by the helpers in lib/utils/action-utils.js.
// This type represents the form of the callServerEndpoint function that
// gets passed to the action function in lib/actions.
export type CallServerEndpoint = (
endpoint: Endpoint,
input: Object,
options?: ?CallServerEndpointOptions,
) => Promise 